home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / m2posx10.zoo / m2posix.10 / src / lib.dpp < prev    next >
Encoding:
Modula Definition  |  1993-12-02  |  9.8 KB  |  209 lines
  1. DEFINITION MODULE lib;
  2. __DEF_SWITCHES__
  3. #ifdef HM2
  4. #ifdef __LONG_WHOLE__
  5. (*$!i+: Modul muss mit $i- uebersetzt werden! *)
  6. (*$!w+: Modul muss mit $w- uebersetzt werden! *)
  7. #else
  8. (*$!i-: Modul muss mit $i+ uebersetzt werden! *)
  9. (*$!w-: Modul muss mit $w+ uebersetzt werden! *)
  10. #endif
  11. #endif
  12. (*****************************************************************************)
  13. (* Verschiedene Bibliotheksfunktionen                                        *)
  14. (* --------------------------------------------------------------------------*)
  15. (* 27-Nov-93, Holger Kleinschmidt                                            *)
  16. (*****************************************************************************)
  17.  
  18. FROM SYSTEM IMPORT
  19. (* TYPE *) ADDRESS;
  20.  
  21. FROM PORTAB IMPORT
  22. (* TYPE *) UNSIGNEDLONG, SIGNEDLONG;
  23.  
  24. #ifdef TSM2_1
  25. FROM AsmLib IMPORT LongLabel;
  26. #endif
  27.  
  28. (*=========================== "rand()" ======================================*)
  29.  
  30. CONST
  31.   RandMax = 7FFFFFFFH;
  32.  
  33. (*================ "lfind()", "bsearch()", "qsort()" ========================*)
  34.  
  35. TYPE
  36.   CompareProc = PROCEDURE ((* par1 *) ADDRESS,
  37.                            (* par2 *) ADDRESS ): INTEGER;
  38.  
  39.   (* par1^  <  par2^  ==>  < 0
  40.    * par1^  =  par2^  ==>  = 0
  41.    * par1^  >  par2^  ==>  > 0
  42.    *
  43.    *
  44.    * Beispiel:
  45.    *
  46.    *   PROCEDURE cmp ((* EIN/ -- *) op1,
  47.    *                  (* EIN/ -- *) op2 : ADDRESS ): INTEGER;
  48.    *
  49.    *   TYPE ElemPtr = POINTER TO REAL; (* je nach Elementtyp *)
  50.    *
  51.    *   VAR ptr1 : ElemPtr;
  52.    *       ptr2 : ElemPtr;
  53.    *
  54.    *   BEGIN
  55.    *    ptr1 := op1;
  56.    *    ptr2 := op2;
  57.    *
  58.    *    IF ptr1^ < ptr2^ THEN
  59.    *      RETURN(-1);
  60.    *    ELSIF ptr1^ > ptr2^  THEN
  61.    *      RETURN(1);
  62.    *    ELSE
  63.    *      RETURN(0);
  64.    *    END;
  65.    *   END cmp;
  66.    *)
  67.  
  68. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  69.  
  70. (* nicht POSIX: *)
  71.  PROCEDURE lfind ((* EIN/ -- *) key     : ADDRESS;
  72.                   (* EIN/ -- *) base    : ADDRESS;
  73.                   (* EIN/ -- *) nelems  : UNSIGNEDLONG;
  74.                   (* EIN/ -- *) size    : UNSIGNEDLONG;
  75.                   (* EIN/ -- *) compare : CompareProc  ): ADDRESS;
  76.  
  77. (*--------------------------------------------------------------------------
  78.  | Prozedur fuer lineare Suche in einem Feld aus gleichartigen, direkt hin- |
  79.  | tereinander angeordneten Elementen (ACHTUNG: Fuellbytes muessen bei der  |
  80.  | Angabe von <size> beruecksichtigt werden!).                              |
  81.  | Falls das gesuchte Element gefunden wird, ist der Funktionswert dessen   |
  82.  | Adresse im Feld, sonst wird NULL zurueckgeliefert.                       |
  83.  |                                                                          |
  84.  | <base>    ist die Adresse des ersten Elementes des Feldes                |
  85.  | <nelems>  ist die Anzahl der Feldelemente                                |
  86.  | <size>    ist die Groesse eine Feldelementes in Bytes                    |
  87.  | <compare> ist die Vergleichsfunktion (siehe Def. 'CompareProc')          |
  88.  | <key>     ist die Adresse des gesuchten Elementes                        |
  89.   --------------------------------------------------------------------------*)
  90.  
  91.  
  92.  PROCEDURE bsearch ((* EIN/ -- *) key     : ADDRESS;
  93.                     (* EIN/ -- *) base    : ADDRESS;
  94.                     (* EIN/ -- *) nelems  : UNSIGNEDLONG;
  95.                     (* EIN/ -- *) size    : UNSIGNEDLONG;
  96.                     (* EIN/ -- *) compare : CompareProc  ): ADDRESS;
  97.  
  98.  
  99. (*--------------------------------------------------------------------------
  100.  | Prozedur fuer binaere Suche in einem Feld aus gleichartigen, direkt hin- |
  101.  | tereinander angeordneten Elementen. Die Elemente muessen gemaess der     |
  102.  | verwendeten Vergleichsprozedur aufsteigend sortiert sein.                |
  103.  | Falls das gesuchte Element gefunden wird, ist der Funktionswert dessen   |
  104.  | Adresse im Feld, sonst wird NULL zurueckgeliefert.                       |
  105.  |                                                                          |
  106.  | Bedeutung der Parameter siehe: "lfind()"                                 |
  107.   --------------------------------------------------------------------------*)
  108.  
  109.  
  110.  
  111.  
  112.  PROCEDURE qsort ((* EIN/ -- *) base    : ADDRESS;
  113.                   (* EIN/ -- *) nelems  : UNSIGNEDLONG;
  114.                   (* EIN/ -- *) size    : UNSIGNEDLONG;
  115.                   (* EIN/ -- *) compare : CompareProc  );
  116.  
  117. (*--------------------------------------------------------------------------
  118.  | Prozedur fuer Sortierung nach dem ``Quicksort''-Algorithmus in einem Feld|
  119.  | aus gleichartigen, direkt hintereinander angeordneten Elementen.         |
  120.  | Die Sortierung ist nicht stabil, d.h. es ist nicht garantiert, dass die  |
  121.  | relative Ordnung von Elementen mit gleichem (Neben-)Schluessel erhalten  |
  122.  | bleibt.                                                                  |
  123.  | Stackbelastung: O(log(nelems))                                           |
  124.  |                                                                          |
  125.  | Bedeutung der Parameter siehe: "lfind()"                                 |
  126.    --------------------------------------------------------------------------*)
  127.  
  128.  
  129.  
  130.  
  131. (* nicht POSIX: *)
  132.  PROCEDURE ltoa ((* EIN/ -- *)     n    : SIGNEDLONG;
  133.                  (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  134.                  (* EIN/ -- *)     base : CARDINAL      );
  135.  
  136.  PROCEDURE ultoa ((* EIN/ -- *)     n    : UNSIGNEDLONG;
  137.                   (* -- /AUS *) VAR str  : ARRAY OF CHAR;
  138.                   (* EIN/ -- *)     base : CARDINAL      );
  139.  
  140. (*--------------------------------------------------------------------------
  141.  | Wandeln den Wert <n> in eine Stringrepraesentation um. Es wird die kuer- |
  142.  | zest moegliche Darstellung gewaehlt, d.h. es werden keine fuehrenden     |
  143.  | Nullen geschrieben, und bei positiven Zahlen wird kein Leerzeichen oder  |
  144.  | ein Plus verwendet. <base> bestimmt die Basis der Zahlendarstellung und  |
  145.  | muss innerhalb von [2..36] liegen; liegt <base> ausserhalb, wird Zehn    |
  146.  | angenommen.                                                              |
  147.   --------------------------------------------------------------------------*)
  148.  
  149.  
  150. (* nicht POSIX: *)
  151.  PROCEDURE strtol ((* EIN/ -- *) REF str  : ARRAY OF CHAR;
  152.                    (* -- /AUS *) VAR end  : CARDINAL;
  153.                    (* EIN/ -- *)     base : CARDINAL      ): SIGNEDLONG;
  154.  
  155.  PROCEDURE strtoul ((* EIN/ -- *) REF str  : ARRAY OF CHAR;
  156.                     (* -- /AUS *) VAR end  : CARDINAL;
  157.                     (* EIN/ -- *)     base : CARDINAL      ): UNSIGNEDLONG;
  158.  
  159. (*--------------------------------------------------------------------------
  160.  | Wandelt die Stringrepraesentation <str> einer Zahl in ihre interne Dar-  |
  161.  | stellung, die als Funktionswert geliefert wird. Die Stringrepraesentation|
  162.  | muss der weiter unten angegebenen Syntax genuegen.                       |
  163.  |                                                                          |
  164.  | <end> ist der Index des ersten fuer die Umwandlung nicht mehr benutzten  |
  165.  | Zeichens; dieser kann auch ausserhalb von <str> liegen, falls die Reprae-|
  166.  | sentation durch das Stringende begrenzt wurde.                           |
  167.  | <base> ist die gewuenschte Basis der Zahl. gueltige Werte sind 0 und 2   |
  168.  | bis 36; andere Werte werden zu Null korrigiert. Ist <base> gleich Null,  |
  169.  | wird die Basis der Repraesentation entnommen, d.h. es koennen Binaer-,   |
  170.  | Oktal- und Sedezimalzahlen erkannt werden; ist der Zahl keine Basis vor- |
  171.  | angestellt, wird eine Dezimalzahl erwartet. Ist <base> gleich 2, 8 oder  |
  172.  | 16, so kann trotzdem zusaetzlich eine Basis der Zahl vorangestellt sein, |
  173.  | sie wird aber ignoriert, solange sie dem Wert von <base> entspricht.     |
  174.  |                                                                          |
  175.  | Wenn bei der Umwandlung ein Ueberlauf auftritt, wird als Funktionswert   |
  176.  | der jeweils groesst/kleinstmoegliche Wert zurueckgeliefert und 'errno'   |
  177.  | auf 'ERANGE' gesetzt.                                                    |
  178.  |                                                                          |
  179.  | Die Syntax:                                                              |
  180.  |                                                                          |
  181.  |   whole      ::= {SPACE}['+'|'-']('%'bin)|('$'hex)|('0'octHexNull)|(num) |
  182.  |                  Stringende|keine gueltige Ziffer                        |
  183.  |   octHexNull ::= ('x'|'X')hex|oct| e (* leer, fuer die NULL *)           |
  184.  |   bin        ::= bindigit{bindigit}                                      |
  185.  |   oct        ::= octdigit{octdigit}                                      |
  186.  |   hex        ::= hexdigit{hexdigit}                                      |
  187.  |   num        ::= digit{digit}                                            |
  188.  |   bindigit   ::= '0'|'1'                                                 |
  189.  |   octdigit   ::= bindigit|'2'..'7'                                       |
  190.  |   hexdigit   ::= octdigit|'8'|'9'|'a'..'f'|'A'..'F'                      |
  191.  |   digit      ::= hexdigit|'g'..'z'|'G'..'Z'                              |
  192.   --------------------------------------------------------------------------*)
  193.  
  194.  
  195.  
  196.  PROCEDURE rand ( ): UNSIGNEDLONG;
  197.  
  198.  PROCEDURE srand ((* EIN/ -- *) seed : UNSIGNEDLONG );
  199.  
  200. (*--------------------------------------------------------------------------
  201.  | "rand()" liefert eine Pseudozufallszahl im Bereich [0..MAXRAND]. Die     |
  202.  | jeweils letzte Zufallszahl wird gemerkt und als Ausgangspunkt fuer die   |
  203.  | Berechnung der naechsten verwendet. Mit "srand()" kann dieser Ausgangs-  |
  204.  | punkt explizit gesetzt werden, sodass reproduzierbare Zahlenfolgen moeg- |
  205.  | lich sind. Zu Programmstart wird als Ausgangswert die eins verwendet.    |
  206.   --------------------------------------------------------------------------*)
  207.  
  208. END lib.
  209.